home *** CD-ROM | disk | FTP | other *** search
/ Collection of Tools & Utilities / Collection of Tools and Utilities.iso / asmutil / uasm.zip / Z8SYM.C < prev    next >
C/C++ Source or Header  |  1986-04-06  |  25KB  |  795 lines
  1. /*
  2.         Custom Computer Consultants
  3.         Universal Cross Assembler
  4.         Z8 Symbols
  5.         5 April 1986
  6. */
  7. #include <stdio.h>
  8. #include <uasm.h>
  9.  
  10. char   *version = {"Z8 Assembler -- V3.5  4/5/86\n"} ;
  11.  
  12.  
  13. #define RSEG    0       /*      Register Segment        */
  14. #define CSEG    1       /*      Code Segment            */
  15. #define DSEG    2       /*      Data Segment            */
  16. #define XSEG    3       /*      External Data Segment   */
  17. #define ASCII   4       /*      String                  */
  18. #define PAGE    5       /*      Page Eject              */
  19. #define RADIX   6       /*      Define Radix            */
  20. #define REG     7       /*      Register Address        */
  21. #define DB      8       /*      Define Byte             */
  22. #define DS      9       /*      Define Storage          */
  23. #define DW      10      /*      Define Word             */
  24. #define EQU     11      /*      Equate                  */
  25. #define ORG     12      /*      Origin                  */
  26.  
  27. extern int     pass1 ;
  28. extern int     lbl ;
  29. extern int     i, j, k ;
  30. extern int     lnspp ;
  31. extern int     cc ;
  32. extern int     ilc ;
  33. extern int     active ;
  34. extern int     instl ;
  35. extern int     parval ;
  36. extern int     radix ;
  37. extern int     cput ;
  38. extern int     syte, sytx ;
  39.  
  40. extern unsigned        unpar ;
  41. extern unsigned        ha, he, hsp ;
  42.  
  43. extern unsigned  char    ch ;
  44. extern unsigned  char    sym ;
  45.  
  46. extern char    *iptr ;  
  47. extern char    segtype[] ;
  48.  
  49. extern unsigned  char    ib[] ;
  50. extern unsigned  char    pv[] ;
  51. extern unsigned  char    px[] ;
  52.  
  53. extern           int     pj[] ;
  54. extern           int     il[] ;
  55. extern char    *pc[], *pseudo[] ;
  56.  
  57. extern int     (*pp[])() ;
  58. extern int     (*ppo[])() ;
  59.  
  60. extern char    ibuf[] ;
  61.  
  62. extern struct  symbol  symtab[] ;
  63.  
  64. #define SYMTYPE  (symtab[sytx].flags&(NSEG-1))
  65.  
  66. code_seg() { return CSEG ; }
  67.  
  68. not_cseg(seg)
  69. int    seg ;
  70. {
  71.        if( seg == RSEG || seg == DSEG ) return TRUE ;
  72.        else return FALSE ;
  73. }
  74.  
  75. set_il()
  76. {
  77.        il[RSEG] =    0 ;
  78.        il[CSEG] =    0 ;
  79.        il[DSEG] =    0 ;
  80.        il[XSEG] = 4096 ;
  81. }
  82.  
  83. set_type()
  84. {
  85.        segtype[RSEG] = '^'  ;
  86.        segtype[CSEG] = '\'' ;
  87.        segtype[DSEG] = '\"' ;
  88.        segtype[XSEG] = '+'  ;
  89. }
  90.  
  91. amatch(s)
  92. char   *s ;
  93. {
  94.        int     tc ;
  95.  
  96.        tc = cc - 1 ;
  97.        while( *s ) {
  98.          if( toupper(ch) != *s++ ) { iptr = &ibuf[cc=tc] ; getch() ;
  99.                                      return FALSE ;
  100.                                      }
  101.          getch() ;
  102.          }
  103.        return TRUE ;
  104. }
  105.  
  106. gen(len)
  107. int     len ;
  108. {
  109.         ib[2] = parval & 0xFF ;
  110.         ib[1] = len == 3 ? parval >> 8 : ib[2] ;
  111.         instl = len ;
  112.         ib[0] = pv[k] ;
  113.         return TRUE ;
  114. }
  115.  
  116. isreg(r)
  117. int    r ;
  118. {
  119.        return ((( r >= 0   ) && ( r <= 127 )) ||
  120.                (( r >= 240 ) && ( r <= 255 ))   ) ;
  121. }
  122.  
  123. iswreg(r)
  124. int    r ;
  125. {
  126.        return (( r >= 0 ) && ( r <= 15 )) ;
  127. }
  128.  
  129. nopr()  { return gen(1) ; }
  130.  
  131. immd()  { if( nomatch("#") )            return FALSE ;
  132.           parval = eval() ;
  133.           return gen(2) ; }
  134.  
  135. dreg()  { parval = eval() ;
  136.           if     (( SYMTYPE == RSEG ) && iswreg(parval)) parval |= 0xE0 ;
  137.           else if(( SYMTYPE == DSEG ) && isreg(parval)) ;
  138.                else push('M') ;
  139.           return gen(2) ; }
  140.  
  141.  
  142. indr()  { if( nomatch("@") )            return FALSE ;
  143.           return dreg() ; }
  144.  
  145. wreg()  { parval = eval() ;
  146.           if ( SYMTYPE != RSEG  )        return FALSE ;
  147.           if ( !iswreg(parval)  )        return FALSE ;
  148.           ib[0] = (pv[k] + (parval << 4 )) ;
  149.           instl = 1 ;
  150.           return TRUE ; }
  151.  
  152. arith()
  153. {        
  154.           int  dst, dt, src, st, mode, type, rc  ;
  155.  
  156.           dt = st = 1 ;        /* Unrecognized         */
  157.           mode = 4 ;           /* Default R,R          */
  158.           rc = TRUE ;
  159.  
  160.           if( amatch("@") ) dt |= 4 ;       /* Set Indirect Flag */
  161.           dst = eval() ; type = SYMTYPE ;
  162.           if( (( type == RSEG ) && iswreg(dst)) ||
  163.               (( type == DSEG ) && isreg(dst)) )   dt = (dt & ~1) | type ;
  164.  
  165.           if( amatch(",#") ) {
  166.               src = eval() ;
  167.               st = 8 ;
  168.               }
  169.           else {
  170.                if( amatch(",@") )    st |= 4 ;
  171.                else if( notcomma() ) return FALSE ;
  172.                src = eval() ; type = SYMTYPE ;
  173.                if( (( type == RSEG ) && iswreg(src)) ||
  174.                    (( type == DSEG ) && isreg(src)) )  st = (st & ~1) | type ;
  175.                }
  176.  
  177.           switch ( dt*10+st ) {
  178.  
  179.             case  0 : mode = 2 ; 
  180.                       goto ww ;
  181.  
  182.             case  4 : mode = 3 ;
  183.             
  184.             ww:       parval = ( dst << 4 ) | src ;
  185.                       instl = 2 ;
  186.                       break ;
  187.  
  188.             case  2 : dst |= 0xE0 ; goto rr ;
  189.  
  190.             case 20 : src |= 0xE0 ; goto rr ;
  191.  
  192.             case 22 : ;
  193.             rr:       mode = 4 ;
  194.                       parval = ( src << 8 ) + dst ;
  195.                       instl = 3 ;
  196.                       break ;
  197.  
  198.             case  6 : dst |= 0xE0 ; goto rir ;
  199.  
  200.             case 24 : src |= 0xE0 ; goto rir ;
  201.  
  202.             case 26 : ;
  203.             rir:      mode = 5 ;
  204.                       parval = ( src << 8 ) + dst ;
  205.                       instl = 3 ;
  206.                       break ;
  207.  
  208.             case  8 : dst |= 0xE0 ; goto rim ;
  209.  
  210.             case 28 : ;
  211.             rim:      mode = 6 ;
  212.                       parval = ( dst << 8 ) + src ;
  213.                       instl = 3 ;
  214.                       break ;
  215.  
  216.             case 48 : dst |= 0xE0 ; goto iim ;
  217.  
  218.             case 68 : ;
  219.             iim:      mode = 7 ;
  220.                       parval = ( dst << 8 ) + src ;
  221.                       instl = 3 ;
  222.                       break ;
  223.  
  224.             default : parval = ( src << 8 ) + dst ;
  225.                       instl = 3 ;
  226.                       rc = FALSE ;
  227.             }
  228.           gen(instl) ;
  229.           ib[0] |= mode ;
  230.           return rc ;
  231. }
  232.  
  233. /*     Destination Type        Source Type
  234.  
  235.        0     r                 r   
  236.        2     R                 R   
  237.        4     @r                @r   
  238.        6     @R                @R   
  239.        8     r(r)              r(r)
  240.        A     R(r)              R(r)
  241.        C      -                #IM
  242. */
  243.  
  244. ldins()
  245. {
  246.        int     dst, dt, src, st, x, type ;
  247.  
  248.        dt = st = 1 ;           /* Unrecognized */
  249.  
  250.        if( amatch("@") )       dt = dt | 4 ;
  251.        dst = eval() ; type = SYMTYPE ;
  252.        if( (( type == RSEG ) && iswreg(dst)) ||
  253.            (( type == DSEG ) && isreg(dst)) )    dt = (dt & ~1) | type ;
  254.        if( amatch("(") ) {
  255.          x = eval() ;  type = SYMTYPE ;
  256.          if(( type == RSEG ) && iswreg(x) )      dt = dt | 8 ;
  257.          if( nomatch(")") )                      return FALSE ;
  258.          }
  259.  
  260.        if( notcomma() )                          return FALSE ;
  261.  
  262.        if( amatch("#") ) { src = eval() ; st = 12 ; }
  263.        else {
  264.          if( amatch("@") )     st = st | 4 ;
  265.          src = eval() ;  type = SYMTYPE ;
  266.          if( (( type == RSEG ) && iswreg(src)) ||
  267.              (( type == DSEG ) && isreg(src)) )  st = (st & ~1) | type ;
  268.          if( amatch("(") ) {
  269.            x = eval() ; type = SYMTYPE ;
  270.            if(( type == RSEG ) && iswreg(x) )    st = st | 8 ;
  271.            if( nomatch(")") )                    return FALSE ;
  272.            }
  273.          }
  274.        switch( dt * 16 + st ) {
  275.  
  276.                      /* 00 - r,r       */
  277.          case   0 :  ib[instl++] = ( dst << 4 ) + 0x08 ;
  278.                      ib[instl++] = src + 0xE0 ;                return TRUE ;
  279.  
  280.                      /* 02 - r,R       */
  281.          case   2 :  ib[instl++] = ( dst << 4 ) + 0x08 ;
  282.                      ib[instl++] = src ;                       return TRUE ;
  283.  
  284.                      /* 04 - r,@r      */
  285.          case   4 :  ib[instl++] = 0xE3 ;
  286.                      ib[instl++] = ( dst << 4 ) + src ;        return TRUE ;
  287.  
  288.                      /* 06 - r,@R      */
  289.          case   6 :  ib[instl++] = 0xE5 ;
  290.                      ib[i